home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 7 / PC World Interactive 7.iso / program / ctutor.exe / SOURCE / DOSEX.C < prev    next >
C/C++ Source or Header  |  1994-05-15  |  10KB  |  273 lines
  1. /*******************************************************************/
  2. /* This is an example program to illustrate how to;                */
  3. /*  1. Get the time and date from DOS                              */
  4. /*  2. Set the cursor to any position on the screen                */
  5. /*  3. Read characters from the keyboard and display their codes   */
  6. /*  4. How to scroll a window up on the monitor                    */
  7. /*  5. Format a program for ease of reading and understanding      */
  8. /*  6. How to do proper prototyping                                */
  9. /*******************************************************************/
  10.  
  11. void draw_box(void);
  12. void disp_char(int inchar);
  13. void get_time(int *hour, int *minute, int *second);
  14. void disp_time_date(void);
  15. void pos_cursor(char row, char column);
  16. void scroll_window(void);
  17.  
  18. #include <stdio.h>
  19. #include <dos.h>
  20. #include <conio.h>
  21.  
  22. int main()
  23. {
  24. int hour, minute, sec, old_sec;
  25. int character;
  26.  
  27.    draw_box();               /* draw the boxes around the fields   */
  28.    old_sec = 0;              /* this variable stores the old time  */
  29.                              /*  so we can look for a change       */
  30.  
  31.    do {
  32.       if (kbhit()) {              /* has a key been hit?           */
  33.          character = getch();     /* read it in                    */
  34.          disp_char(character);    /* display it                    */
  35.       }
  36.  
  37.       get_time(&hour, &minute, &sec); /* get the time of day       */
  38.       if (sec != old_sec) {       /* if it has changed,            */
  39.          disp_time_date();        /* update the display            */
  40.          old_sec = sec;           /* save new time                 */
  41.       }
  42.  
  43.    } while (character != 'Q');    /* Quit when a Q is found        */
  44.  
  45.    pos_cursor(0, 0);              /* put cursor at top of screen   */
  46. }
  47.  
  48.  
  49.  
  50. /********************************************************* drawbox */
  51. /* This routine draws a box on the screen. The keys hit, and the   */
  52. /*  time and date are displayed in these boxes. There is nothing   */
  53. /*  special about these boxes, they are simply output using the    */
  54. /*  printf function.                                               */
  55. /*******************************************************************/
  56. void draw_box(void)
  57. {
  58. int index;
  59. char line[81];
  60.  
  61.    for (index = 0 ; index < 80 ; index++) /* three blank rows      */
  62.       line[index] = ' ';
  63.    line[80] = NULL;          /* end of string                      */
  64.    for (index = 0 ; index < 3 ; index++)
  65.       printf("%s", line);
  66.  
  67.    line[8] = 201;            /* draw top line of box               */
  68.    for (index = 9 ; index < 70 ; index++)
  69.       line[index] = 205;
  70.    line[70] = 187;
  71.    printf("%s", line);
  72.  
  73.    line[8] = 186;            /* draw sides of large box            */
  74.    for (index = 9 ; index < 70 ; index++)
  75.       line[index] = ' ';
  76.    line[70] = 186;
  77.    for (index = 0 ; index < 15 ; index++)
  78.       printf("%s", line);
  79.  
  80.    line[8] = 204;            /* draw line between boxes            */
  81.    for (index = 9 ; index < 70 ; index++)
  82.       line[index] = 205;
  83.    line[70] = 185;
  84.    printf("%s", line);
  85.  
  86.    line[8] = 186;            /* sides for time/date box            */
  87.    for (index = 9 ; index < 70 ; index++)
  88.       line[index] = ' ';
  89.    line[70] = 186;
  90.    printf("%s", line);
  91.  
  92.    line[8] = 200;            /* bottom line of the box             */
  93.    for (index = 9 ; index < 70 ; index++)
  94.       line[index] = 205;
  95.    line[70] = 188;
  96.    printf("%s", line);
  97.  
  98.    for (index = 0 ; index < 80 ; index++) /* three blank rows      */
  99.       line[index] = ' ';
  100.    for (index = 0 ; index < 3 ; index++)
  101.       printf("%s", line);
  102.  
  103. }
  104.  
  105.  
  106.  
  107. /******************************************************* disp_char */
  108. /* This routine displays the characters hit on the monitor.  If    */
  109. /*  the first character is a zero, a special character has been    */
  110. /*  hit, and the zero is displayed. The next character is read,    */
  111. /*  and it is displayed on the monitor.                            */
  112. /*******************************************************************/
  113. void disp_char(int inchar)
  114. {
  115.    scroll_window();
  116.    pos_cursor(17, 15);       /* position of message on screen      */
  117.  
  118.    if(inchar == 0) {
  119.       printf(" 00 ");        /* a special character was hit        */
  120.       inchar = getch();      /* get the next part of it            */
  121.       switch (inchar) {
  122.          case 59  :
  123.          case 60  :
  124.          case 61  :
  125.          case 62  :
  126.          case 63  :          /* these are the function keys        */
  127.          case 64  :
  128.          case 65  :
  129.          case 66  :
  130.          case 67  :
  131.          case 68  : printf("%4d Function key F%d\n", 
  132.                                                 inchar, inchar - 58);
  133.                     break;
  134.  
  135.          case 94  :
  136.          case 95  :
  137.          case 96  :
  138.          case 97  :
  139.          case 98  :          /* these are the ctrl-function keys   */
  140.          case 99  :
  141.          case 100 :
  142.          case 101 :
  143.          case 102 :
  144.          case 103 : printf("%4d Function key Ctrl-F%d\n", 
  145.                                                 inchar, inchar - 93);
  146.                     break;
  147.  
  148.          case 84  :
  149.          case 85  :
  150.          case 86  :
  151.          case 87  :          /* these are the upper-function keys  */
  152.          case 88  :
  153.          case 89  :
  154.          case 90  :
  155.          case 91  :
  156.          case 92  :
  157.          case 93  : printf("%4d Function key Upper-F%d\n",
  158.                                                 inchar, inchar - 83);
  159.                     break;
  160.  
  161.          case 104 :
  162.          case 105 :
  163.          case 106 :
  164.          case 107 :
  165.          case 108 :          /* these are the alt-function keys    */
  166.          case 109 :
  167.          case 110 :
  168.          case 111 :
  169.          case 112 :
  170.          case 113 : printf("%4d Function key Alt-F%d\n",
  171.                                                inchar, inchar - 103);
  172.                     break;
  173.  
  174.          default  : printf("%4d Special key hit\n", inchar);
  175.       }
  176.  
  177.    } else                    /* a regular character was hit        */
  178.       printf("    %4d (%c) Character Hit.\n", inchar, inchar);
  179.  
  180.    pos_cursor(25, 1);        /* hide the cursor on the 26th line   */
  181. }
  182.  
  183.  
  184.  
  185. /******************************************************** get_time */
  186. /* This routine calls the DOS function call for time of day. It    */
  187. /*  returns the time of day to the calling program in the three    */
  188. /*  pointers used in the call.                                     */
  189. /*******************************************************************/
  190. void get_time(int *hour, int *minute, int *second)
  191. {
  192. union REGS inregs;
  193. union REGS outregs;
  194.  
  195.    inregs.h.ah = 44;         /* Hex 2C - Get current time          */
  196.    int86(0x21, &inregs, &outregs);
  197.    *hour = outregs.h.ch;
  198.    *minute = outregs.h.cl;
  199.    *second = outregs.h.dh;
  200. }
  201.  
  202.  
  203.  
  204. /************************************************** disp_time_date */
  205. /* This routine displays the time and date on the monitor in a     */
  206. /*  fixed position. It gets the time from the get_time function,   */
  207. /*  and gets the date from its own built in DOS call.  Good pro-   */
  208. /*  gramming practice would move the date to another function but  */
  209. /*  this is an illustrative example to display methods of doing    */
  210. /*  things.  This routine also calls the cursor positioning        */
  211. /*  function to put the time and date where we want them.          */
  212. /*******************************************************************/
  213. void disp_time_date(void)
  214. {
  215. int hour, minute, second;
  216. union REGS inregs;
  217. union REGS outregs;
  218.  
  219.    pos_cursor(19, 19);  /* position the cursor for date and time   */
  220.  
  221.    inregs.h.ah = 42;              /* hex 2A - What is the date?    */
  222.    int86(0x21, &inregs, &outregs);  /* interrupt 21                */
  223.    printf("Date = %2d/%2d/%2d    ",
  224.                   outregs.h.dh,   /* month - 1 to 12               */
  225.                   outregs.h.dl,   /* day - 1 to 31                 */
  226.                   outregs.x.cx);  /* year - 1980 to 2099           */
  227.  
  228.    get_time(&hour, &minute, &second);
  229.    printf("Time = %2d:%2d:%2d\n", hour, minute, second);
  230.  
  231.    pos_cursor(25, 1);        /* hide the cursor on the 26th line   */
  232. }
  233.  
  234.  
  235.  
  236. /****************************************************** pos_cursor */
  237. /* This routine positions the cursor at the requested row and      */
  238. /*  column. The upper left corner is row 0 and column 0            */
  239. /*******************************************************************/
  240. void pos_cursor(char row, char column)
  241. {
  242. union REGS inregs;
  243. union REGS outregs;
  244.  
  245.    inregs.h.ah = 2;          /* service 2 - position the cursor    */
  246.    inregs.h.dh = row;
  247.    inregs.h.dl = column;
  248.    inregs.h.bh = 0;
  249.    int86(0x10, &inregs, &outregs);  /* interrupt 10                */
  250. }
  251.  
  252.  
  253.  
  254. /*************************************************** scroll_window */
  255. /* This routine scrolls all of the material in the key hit window  */
  256. /*  up one space leaving room for another entry.                   */
  257. /*******************************************************************/
  258. void scroll_window(void)
  259. {
  260. union REGS inregs;
  261. union REGS outregs;
  262.  
  263.    inregs.h.ah = 6;          /* service 6 - scroll window          */
  264.    inregs.h.al = 1;          /* number of lines to scroll          */
  265.    inregs.h.ch = 3;          /* top row of window                  */
  266.    inregs.h.cl = 9;          /* left column of window              */
  267.    inregs.h.dh = 17;         /* bottom row of window               */
  268.    inregs.h.dl = 69;         /* right column of window             */
  269.    inregs.h.bh = 7;          /* attribute of blank line            */
  270.    int86(0x10, &inregs, &outregs);  /* interrupt 10                */
  271.  
  272. }
  273.